約 2,744,755 件
https://w.atwiki.jp/tmiya/pages/55.html
初心者の為の練習問題 原文はScala exercises for beginnersを参照の事。 関数型言語の初心者向けの良い課題だと思うのだが。...が、関数型言語に不慣れだと、そもそもどんな関数を作る事が期待されているのか判んないかもしれないなぁ。(メソッド名とか関数の型から大体の見当がつくかな?) ソースコード中の error("課題") の部分を自分の書いたコードで置き換える事が期待されています。 初心者の回答を自動で採点する為に、scalacheck で回答の正当性を検証する為の方法を誰か解説しない? // 下記の List のメソッドは使用してはならない // * length // * map // * filter // * (および ++ のようなその変形) // * flatten // * flatMap // * reverse (および reverseMap, reverse_ のような変形) // これはまた、List に対する for-構文の使用も禁止している。 // 自分で書いた関数は使用して良い。例えば問題 2 では問題 1 あるいは問題 3 を使用して良い。 // 許可された既に存在するメソッドを適切に使用した場合は、エレガントさが評価される。 // 満点 66点 object Exercises { def succ(n Int) = n + 1 def pred(n Int) = n - 1 // Exercise 1 (問題 1) // Relative Difficulty 1 (難易度 1) // Correctness 2.0 (正しい回答に 2.0 点) // Performance 0.5 (性能 0.5 点) // Elegance 0.5 (エレガントさ 0.5 点) // Total 3 (合計 3) def add(x Int, y Int) Int = error("課題 x, yは 0 または正の数と仮定せよ。Int に対する +, - の使用を禁止する。上述の succ/pred の使用のみ許す。") // Exercise 2 // Relative Difficulty 2 // Correctness 2.5 marks // Performance 1 mark // Elegance 0.5 marks // Total 4 def sum(x List[Int]) Int = error("課題") // Exercise 3 // Relative Difficulty 2 // Correctness 2.5 marks // Performance 1 mark // Elegance 0.5 marks // Total 4 def length[A](x List[A]) Int = error("課題") // Exercise 4 // Relative Difficulty 5 // Correctness 4.5 marks // Performance 1.0 mark // Elegance 1.5 marks // Total 7 def map[A, B](x List[A], f A = B) List[B] = error("課題") // Exercise 5 // Relative Difficulty 5 // Correctness 4.5 marks // Performance 1.5 marks // Elegance 1 mark // Total 7 def filter[A](x List[A], f A = Boolean) List[A] = error("課題") // Exercise 6 // Relative Difficulty 5 // Correctness 4.5 marks // Performance 1.5 marks // Elegance 1 mark // Total 7 def append[A](x List[A], y List[A]) List[A] = error("課題") // Exercise 7 // Relative Difficulty 5 // Correctness 4.5 marks // Performance 1.5 marks // Elegance 1 mark // Total 7 def concat[A](x List[List[A]]) List[A] = error("課題") // Exercise 8 // Relative Difficulty 7 // Correctness 5.0 marks // Performance 1.5 marks // Elegance 1.5 mark // Total 8 def concatMap[A, B](x List[A], f A = List[B]) List[B] = error("課題") // Exercise 9 // Relative Difficulty 8 // Correctness 3.5 marks // Performance 3.0 marks // Elegance 2.5 marks // Total 9 def maximum(x List[Int]) Int = error("課題") // Exercise 10 // Relative Difficulty 10 // Correctness 5.0 marks // Performance 2.5 marks // Elegance 2.5 marks // Total 10 def reverse[A](x List[A]) List[A] = error("課題") } 答え合わせってどうすれば? -- _kzt_ (2010-01-09 12 08 58) あ、答えっていうのは変ですね。回答例かな。 -- _kzt_ (2010-01-09 12 12 24) 名前 コメント
https://w.atwiki.jp/feenal/pages/101.html
Razorscale 25man Ulduar ハードモードコンプリートのごほうびMountはこいつ Ability(Phase 1) 火の玉 ランダムで誰かにFrostfire Boltっぽい火の玉を撃ち込む。 青い火 ランダムで誰かに青い炎を撃ち込む。直後に地面が燃え出し、その上にいるプレイヤーにダメージ。 Wing Buffet ハープーンで叩き落された後、時間切れ ハープーンで叩き落された後、Phase2に以降 のどちらかで使用。みんなふっとばされる。 Ability(Phase 2) Flame Buffet 全員に被Fireダメージ+1500のDebuffを1個乗っける。99個までスタックするので実質Soft Enrage Timer。 Fuse Armor 20秒間、TankのArmor/AttackSpeed/MoveSpeedをがた落ちさせる。5個スタックすると長時間完全スタンし、実質死亡扱い Flame Breath 正面に大ダメージ 青い火 P1と同じ。Tankにしか使わない(と思われる) Strategy - Phase1 Razorscaleは空を飛んでおり、通常攻撃は届かない。NPCが戦闘地点入り口にある壊れたハープーンを一定時間ごとに修理するので、 それを4台(10manは2台)Activateしてぶちこむことで一定時間、Razorscaleを地面に引き摺り下ろせる。 Razorscaleが地面に落ちてくるまでは一定時間毎にAddが沸くのでTankがキャッチし、ハープーンの修理を待ちながら掃除することになる。 Addは基本的に雑魚だが、Caster TypeのChain LightningとMelee Type(大)のWhirlwindには注意。特に後者。 Melee(大)はドリルマシンが3台出現したときのみpopするのですぐわかる。 Razorscaleの吐く青い炎も足元に出たら即回避しないとTank以外は3tick程度で死ぬ。 ハープーンは誰かがActivateしないと動かないので、誰か一人が側まで走っていって使用していく。 最後の1本をActivateした時点でAddの沸きが一時的にストップするので、使用するタイミングは考える必要がある。 落ちてきたRazorscaleは一切行動しないので、Threatを気にせず全力で攻撃することが出来る。 一定時間が経過するとRazorscaleはWing Buffetを使用してプレイヤーとハープーンを吹き飛ばして再び空中に逃げ、Addが沸き始める。 RazorscaleのHPが50%になるまではこれの繰り返し。 ThreatはPhase 2に持ち越しなので、Phase 2に切り替わる瞬間にDPSは手を止め、TankはTauntでThreatをトップにしておく必要がある。 Strategy - Phase2 Tankの足元に出る青い炎を避けながら、Flame Buffetによる限界が来る前に倒すBurn Down Fight。 TankにくるDebuffが5枚たまってしまうと(実質)死亡扱いになるのでその前に2nd TankがTauntで引き剥がす。 RazorscaleのMeleeはArmor減少の効果もあって相当痛いのでHealerは全力Heal。 Soft/Hard Enrage共に時間的にかなり余裕があるので、Bloodlust/HeroismのタイミングはPhase1でもPhase2でも構わない。
https://w.atwiki.jp/robotictooluse/pages/16.html
http //193.6.4.39/~czap/letoltes/IS14/IS2014/PDF/AUTHOR/IS141304.PDF Hasim Sak, Andrew Senior, Francoise Beaufays Google, USA Abstract Long Short-Term Memory (LSTM) is a specific recurrent neural network (RNN) architecture that was designed to model temporal sequences and their long-range dependencies more accurately than conventional RNNs. In this paper, we explore LSTM RNN architectures for large scale acoustic modeling in speech recognition. We recently showed that LSTM RNNs are more effective than DNNs and conventional RNNs for acoustic modeling, considering moderately-sized models trained on a single machine. Here, we introduce the first distributed training of LSTM RNNs using asynchronous stochastic gradient descent optimization on a large cluster of machines. We show that a two-layer deep LSTM RNN where each LSTM layer has a linear recurrent projection layer can exceed state-of-the-art speech recognition performance. This architecture makes more effective use of model parameters than the others considered, converges quickly, and outperforms a deep feed forward neural network having an order of magnitude more parameters. Index Terms Long Short-Term Memory, LSTM, recurrent neural network, RNN, speech recognition, acoustic modeling. 1. どんなもの LSTMの計算量を下げ,かつパラメータの収束が早いLSTMP(Long Short-Term Memory)を提案した論文。 2. 先行研究と比べてどこがすごい LSTMのおおよその計算量はメモリーセルの数×(4×メモリーセルの数+出力層のユニット数)であるが,LSTMPのおおよその計算量はリカレントプロジェクション層のユニット数×(4×メモリーセルの数+出力層のユニット数)となる。これによって,計算量が減り,パラメータの収束が速くなる。 3. 技術や手法の肝はどこ? 従来のLSTMでは,メモリーセルレイヤーからの出力がそのまま次のステップの入力になる。 提案するLSTMでは,メモリーセルレイヤーからの出力にさらに重みパラメータをかけて次のステップの入力とする。 4. どうやって有効だと検証した? 音響モデルの学習に関してはあまり理解できていないが, Google Voice Search in US Englishというデータセットを使い,1900時間分のデータを学習させていた。 5. 議論はある? メモリーセルの数が多ければ多いほどオーバーフィッティングしやすくなる。深層にすることで一般化に優れる。 6. 次に読むべき論文は? 7. その他
https://w.atwiki.jp/tmiya/pages/127.html
Scala ひと巡り ジェネリッククラス (Generic Classes) 原ページ Java 5 (aka.JDK 1.5 [58])と同じように、Scala は、型がパラメータ化されたクラスを組み込でサポートしています。そのようなジェネリッククラスは、コレクションクラスの開発に特に役立ちます。 次はこのことを示す例です class Stack[T] { var elems List[T] = Nil def push(x T) { elems = x elems } def top T = elems.head def pop() { elems = elems.tail } } クラス Stack は、任意の要素型 T の命令型(ミュータブル 更新可能な)スタックをモデル化します。型パラメータの使用により、正しい要素(つまり型が T のもの)だけがスタック上に push されるようにできます。同様に、型パラメータを用いてメソッド top が、与えられた型の要素だけを出力することを表現できます。 次は使用方法を示すいくつかの例です object GenericsTest extends Application { val stack = new Stack[Int] stack.push(1) stack.push('a') println(stack.top) stack.pop() println(stack.top) } 次は、このプログラムの出力です。 97 1 ジェネリック型のサブ型付けは、非変であることに注意してください。これは、もし型 Stack[Char] の文字スタックがあっても、それを型 Stack[Int] の整数スタックとしては使えないことを意味します。それでは、本当の整数を文字スタックに入れることがでてしまうので、不健全でしょう。結論を言えば、ただ S = T の場合に限り、Stack[T] は Stack[S] のサブ型になります。これは非常に制約が厳しいので、Scala は、ジェネリック型のサブ型付けの振る舞いをコントロールする、型パラメータのアノテーション機構 [17]を提供しています。 Scala ひと巡り 暗黙のパラメータ (Implicit Parameters) 原ページ 暗黙のパラメータをもつメソッドは、通常のメソッドとまったく同じように引数に適用されます。この場合、implicit ラベルは効果を持ちません。しかし、もしメソッドにその暗黙のパラメータに対する引数が書かれていないなら、そのような引数は自動的に供給されます。 暗黙のパラメータに渡すに適した実際の引数は、2 つのカテゴリに分けられます。 1 つめは、メソッド呼び出しの時点でアクセスできる、前置子のつかない、implicit 定義あるいは暗黙のパラメータを表す、すべての識別子 x が適しています。 2 つめは、implicit と印された暗黙のパラメータの型のコンパニオンモジュールのすべてのメンバーも適しています。 次の例は、monoid の add と unit 操作を使ってリストの要素の合計を計算する、メソッド sum を定義しています。暗黙の値がトップレベルではいけないことに注意してください。それらはテンプレートのメンバーでなければなりません。 abstract class SemiGroup[A] { def add(x A, y A) A } abstract class Monoid[A] extends SemiGroup[A] { def unit A } object ImplicitTest extends Application { implicit object StringMonoid extends Monoid[String] { def add(x String, y String) String = x concat y def unit String = "" } implicit object IntMonoid extends Monoid[Int] { def add(x Int, y Int) Int = x + y def unit Int = 0 } def sum[A](xs List[A])(implicit m Monoid[A]) A = if (xs.isEmpty) m.unit else m.add(xs.head, sum(xs.tail)) println(sum(List(1, 2, 3))) println(sum(List("a", "b", "c"))) } 次は Scala プログラムの出力です 6 abc Scala ひと巡り 内部クラス (Inner Classes) 原ページ Scala では、クラスは他のクラスをメンバーとして持てます。Java ライクな言語では、そのような内部クラスは取り囲むクラスのメンバーですが、Scala では反対に、そのような内部クラスは外側のオブジェクトへ束縛されます。違いを明らかにするために、グラフデータ型の実装概要を示します class Graph { class Node { var connectedNodes List[Node] = Nil def connectTo(node Node) { if (connectedNodes.find(node.equals).isEmpty) { connectedNodes = node connectedNodes } } } var nodes List[Node] = Nil def newNode Node = { val res = new Node nodes = res nodes res } } このプログラムで、グラフはノードのリストによって表されます。ノードは内部クラス Node のオブジェクトです。各ノードは 隣のリストを持っており、それはリスト connectedNodes 中に記憶されます。これでいくつかのノードをもち、ノードを付加的に(incrementally)連結できるグラフをセットアップできます。 object GraphTest extends Application { val g = new Graph val n1 = g.newNode val n2 = g.newNode val n3 = g.newNode n1.connectTo(n2) n3.connectTo(n1) } 次に、定義されるエンティティの型が何であるかを明示する型を用いて、例を補強します object GraphTest extends Application { val g Graph = new Graph val n1 g.Node = g.newNode val n2 g.Node = g.newNode val n3 g.Node = g.newNode n1.connectTo(n2) n3.connectTo(n1) } このコードは、ノードの型が、その外側のインスタンス(この例ではオブジェクト g )で前置されることを明らかにしています。今 2 つのグラフがあるとして、Scala の型システムは、一方のグラフ内で定義されたノードと他方のグラフのノードを混ぜることを許しません。なぜなら、他のグラフのノードは異なる型をもつからです。 次は不正なプログラムです object IllegalGraphTest extends Application { val g Graph = new Graph val n1 g.Node = g.newNode val n2 g.Node = g.newNode n1.connectTo(n2) // 正しい val h Graph = new Graph val n3 h.Node = h.newNode n1.connectTo(n3) // 不正! } Javaでは、上記サンプルプログラムの最後の行は正しいことに注意してください。Java は両方のグラフのノードに同じ型 Graph.Node を割り当てます。すなわち、Node はクラス Graph で前置されます(*1)。 Scalaでは、そのような型も表現でき、Graph#Node と書きます。もし異なるグラフのノードを連結できるようにしたければ、最初のグラフ実装の定義を次のように変える必要があります。 class Graph { class Node { var connectedNodes List[Graph#Node] = Nil def connectTo(node Graph#Node) { if (connectedNodes.find(node.equals).isEmpty) { connectedNodes = node connectedNodes } } } var nodes List[Node] = Nil def newNode Node = { val res = new Node nodes = res nodes res } } このプログラムが、2 つの異なるグラフへのノードの張りつけを許さないことに注意してください。もしこの制限もなくしたければ、変数 nodes の型とメソッド newNode の戻り値型を Graph#Node に変える必要があります。 (*1)訳注: Scalaではクラス Graph ではなくオブジェクト g が前置されていて、 g.Node と h.Node はパスが異なるので異なる型を表すということ。 Scala ひと巡り ミックスインクラス合成 (Mixin Class Composition) 原ページ 単一継承のみをサポートする言語と対照して、Scala には、クラス再利用のためのより汎用的な概念があります。Scala では、クラスの新しいメンバー定義(すなわち、スーパークラス継承の差分)を再利用できます。これはミックスインクラス合成として表現されます。イテレータに関する次の抽象化を考えてみます。 abstract class AbsIterator { type T def hasNext Boolean def next T } 次に、メソッド foreach を用いて AbsIterator を展開するミックスインクラスについて考えます。ここで foreach は、イテレータが返す各要素に与えられた関数を適用します。ミックスインとして使用できるクラスを定義するのに、キーワード trait を使います。 trait RichIterator extends AbsIterator { def foreach(f T = Unit) { while (hasNext) f(next) } } 次は、与えられた文字列の文字を次々に返す、具象イテレータクラスです class StringIterator(s String) extends AbsIterator { type T = Char private var i = 0 def hasNext = i s.length() def next = { val ch = s charAt i; i += 1; ch } } StringIterator と RichIterator の機能を 1 つのクラスへ統合したいとします。これは単一継承とインタフェースだけではできません。両クラスともコードを伴うメンバー実装を含むからです。Scala では、ミックスインクラス合成を使ってできます。プログラマはクラス定義の差分 --- すなわち、継承さていれないすべての新しい定義 --- を再利用できます。この機構により、次のテストプログラムのようにして、RichIterator と StringIterator を統合できます。次は、与えられた文字列のすべての文字のカラムを印字します。 object StringIteratorTest { def main(args Array[String]) { class Iter extends StringIterator(args(0)) with RichIterator val iter = new Iter iter foreach println } } 関数 main 中の Iter クラスは、親の StringIterator と RichIterator をキーワード with を使ってミックスイン合成し、構築されています。最初の親は Iter のスーパークラスと呼ばれるのに対し、2 つめ(と、もしあればその他すべて)の親は、ミックスインと呼ばれます。 Scala ひと巡り 関数のネスト (Nested Functions) 原ページ Scala では、関数定義をネストできます。次のオブジェクトは、整数のリストから閾値未満の値を抽出する、filter 関数を提供します object FilterTest extends Application { def filter(xs List[Int], threshold Int) = { def process(ys List[Int]) List[Int] = if (ys.isEmpty) ys else if (ys.head threshold) ys.head process(ys.tail) else process(ys.tail) process(xs) } println(filter(List(1, 9, 2, 8, 3, 7, 4), 5)) } ネストされた関数 process が、filter のパラメータ値である外側のスコープ中で定義された変数 threshold を参照することに注意してください。 次はこのプログラムの出力です List(1,2,3,4) Scala ひと巡り 無名関数の構文 (Anonymous Function Syntax) 原ページ Scala は無名関数の定義について、比較的簡単な構文を提供します。次の式は、整数の後続関数を生成します (x Int) = x + 1 これは次の、無名クラス定義の略記表現です new Function1[Int, Int] { def apply(x Int) Int = x + 1 } 複数のパラメータをもつ関数も定義できます。 (x Int, y Int) = "(" + x + ", " + y + ")" あるいは、パラメータなしの関数 () = { System.getProperty("user.dir") } 関数の型を書くためのたいへん簡単な方法もあります。次は、上で定義した 3 つの関数の型です Int = Int (Int, Int) = String () = String この構文は、次の型の略記表現です Function1[Int, Int] Function2[Int, Int, String] Function0[String] Scala ひと巡り カリー化 (Currying) 原ページ メソッドは複数のパラメータリストを定義できます。メソッドは、パラメータリストの数より少ない形で呼び出される時には、その引数としてパラメータリストを失った関数をもたらします。 次は 1 つの例です object CurryTest extends Application { def filter(xs List[Int], p Int = Boolean) List[Int] = if (xs.isEmpty) xs else if (p(xs.head)) xs.head filter(xs.tail, p) else filter(xs.tail, p) def modN(n Int)(x Int) = ((x % n) == 0) val nums = List(1, 2, 3, 4, 5, 6, 7, 8) println(filter(nums, modN(2))) println(filter(nums, modN(3))) } 2 つの filter 呼び出しにおいて、メソッド modN が部分適用されることに注意してください; すなわち、その最初の引数だけが実際に適用されます。項 modN(2) は、型 Int = Boolean の関数をもたらし、それはこのように、関数 filter の 2 番目の引数に対する可能な候補となります。 次は、上記プログラムの出力です List(2,4,6,8) List(3,6) Scala ひと巡り 型依存クロージャの自動構築 (Automatic Type-Dependent Closure Construction) 原ページ uction) Scala では、メソッドのパラメータにパラメータなしの関数名を与えることができます。そのようなメソッドが呼ばれる時、パラメータなしの関数名に対する実際のパラメータは評価されず、代わりにパラメータなしの関数が渡されます。これは対応するパラメータの計算をカプセル化します(いわゆる、名前呼出し評価)。 次のコードはこのメカニズムを示します object TargetTest1 extends Application { def whileLoop(cond = Boolean)(body = Unit) Unit = if (cond) { body whileLoop(cond)(body) } var i = 10 whileLoop (i 0) { println(i) i -= 1 } } 関数 whileLoop は、2 つのパラメータ cond と body をとります。関数の適用時、実際のパラメータは評価されません。しかしその代わりに、whileLoop の本体中で形式上のパラメータが使われる毎に、暗黙のうちに生成されるパラメータなしの関数が評価されます。このように、このメソッド whileLoop は、再帰的な実装方式の Java ライクな while-loop を実装します。 中置/後置演算子 [27] とこのメカニズムを結びつけて、(洗練された構文を用いた)より複雑な文を作れます。 次は loop-unless 文の実装です object TargetTest2 extends Application { def loop(body = Unit) LoopUnlessCond = new LoopUnlessCond(body) protected class LoopUnlessCond(body = Unit) { def unless(cond = Boolean) { body if (!cond) unless(cond) } } var i = 10 loop { println("i = " + i) i -= 1 } unless (i == 0) } loop 関数はただループの本体を受けつけるだけであり、そして(この本体オブジェクトをカプセル化する)クラス LoopUnlessCond のインスタンスを返します。本体がまだ評価されないことに注意してください。クラス LoopUnlessCond はメソッド unless を持っており、それを中置演算子として使用できます。このように、新たなループ loop { stats } unless ( cond ) の、極めて自然な構文を作れます 次は、TargetTest2 を実行したときの出力です i = 10 i = 9 i = 8 i = 7 i = 6 i = 5 i = 4 i = 3 i = 2 i = 1 Scala ひと巡り オペレータ (Operators) 原ページ Scala では、ただ 1 つのパラメータをとるどのようなメソッドも中置演算子として使えます。 次は、3 つのメソッド and、or と negate を定義する classMyBool の定義です。 class MyBool(x Boolean) { def and(that MyBool) MyBool = if (x) that else this def or(that MyBool) MyBool = if (x) this else that def negate MyBool = new MyBool(!x) } ここで、and と or を中置演算子として使えます。 def not(x MyBool) = x negate; // ここではセミコロンが必要 def xor(x MyBool, y MyBool) = (x or y) and not(x and y) このコードの最初の行のように、パラメータなしのメソッドを後置演算子としても使用えます。2 番目の行は、新しい not 関数と同様に、and および or メソッドを使って xor 関数を定義します。この例で、中置演算子を使って xor 定義がいっそう理解しやすくなっています。 次は、より伝統的なオブジェクト指向プログラミング言語構文における、対応するコードです def not(x MyBool) = x.negate; // semicolon required here def xor(x MyBool, y MyBool) = x.or(y).and(x.and(y).negate) Scala ひと巡り 高階関数 (Higher-Order Functions) 原ページ Scala では、高階関数を定義できます。それらは、パラメータに他の関数をとるか、あるいは、その結果が関数であるような、関数です。 次は、他の関数 f と値 v をとり、関数 f を v に適用する、関数 apply です。 def apply(f Int = String, v Int) = f(v) もしコンテキスト上で必要なら、メソッドが関数へ自動的に特化(coerced 強制)されることに注意してください。 次は 1 つの例です class Decorator(left String, right String) { def layout[A](x A) = left + x.toString() + right } object FunTest extends Application { def apply(f Int = String, v Int) = f(v) val decorator = new Decorator("[", "]") println(apply(decorator.layout, 7)) } 実行すると次の出力となります。 [7] この例で、メソッド decorator.layout は、メソッド apply が必要とするときに、型 Int = String の値へ自動的に特化されます。メソッド decorator.layout が多相的メソッドであり(すなわち、いくつかのシグニチャ型にわたっての抽象化)、Scala コンパイラは最初にそのメソッド型を適切にインスタンス化しなければならないことに注意してください。 Scala ひと巡り パッケージ (Packages) 原ページ パッケージはメンバークラス、オブジェクトとパッケージの集合を定義する特別なオブジェクトです。他のオブジェクトと異なり、パッケージは定義では導入できません。 パッケージング package p { ds } は、ds 中のすべての定義をその限定修飾名が p であるパッケージに、メンバーとして注入します。パッケージのメンバーはトップレベル定義と呼ばれます。もし ds 中の定義が private と印されていれば、そのパッケージ中の他のメンバーに対してのみ可視となります。 protected 修飾子をパッケージ識別子 p で限定できます(たとえば protected[p])。そのような修飾子を印されたメンバーは、パッケージ p 内のすべてのコードから同様にアクセス可能です。 p からの選択 p.m は、p からのインポートと同様、オブジェクトに関して機能します。しかし、他のオブジェクトと異なり、パッケージは値としては使用できません。モジュールあるいはクラス名と、同じ完全修飾名のパッケージは不正です。 パッケージング外でのトップレベル定義は、特別な空パッケージに注入されるとみなされます。このパッケージは、名前を付けることはできず、したがってインポートできません。しかし、空パッケージのメンバーは互いに限定修飾なしで可視です。 パッケージ節ではじまるコンパイル単位 package p ; stats は、ただ 1 つのパッケージング package p { stats } からなるコンパイル単位と同じです。 同じ Scala ソースファイル中で、複数のパッケージを宣言できます。 package p1 { object [[test]] extends Application { println("p1.test") } } package p2 { object test extends Application { println("p2.test") } } インポート節 インポート節は、import p.I の形をしています。ここで、インポート式 I は、限定修飾なしでアクセスできる、p のインポート可能なメンバー名の集合を決定します。たとえば 節 限定修飾なしで利用可能 import p._ p の全てのメンバー (Javaにおける import p.* と類似) import p.x p のメンバー x import p.{x = a} p のメンバー x を a にリネーム import p.{x, y} p のメンバー x と y import p1.p2.z p2 のメンバー z 。p2 自身は p1 のメンバー また、節 import p1._ , p2._ は、import p1._; import p2._ の略記表現です。 次は、すべてのコンパイル単位中に暗黙のうちに、この順番でインポートされます。 パッケージ java.lang、 パッケージ Scala と オブジェクト scala.Predef この順番において、後でインポートしたメンバーは、前にインポートしたメンバーを隠します。 Scala ひと巡り パターンマッチング (Pattern Matching) 原ページ Scala には、汎用的なパターンマッチング機構が組み込まれています。ファーストマッチ方式で、あらゆる種類のデータ上でマッチングさせることができます。 次は、整数値に対するマッチ方法を示す、小さな例です object MatchTest1 extends Application { def matchTest(x Int) String = x match { case 1 = "one" case 2 = "two" case _ = "many" } println(matchTest(3)) } ケース文のブロックは、整数を文字列にマップする関数を定義します。match キーワードは、オブジェクトに関数を適用する(上記のパターンマッチング関数のような)便利な方法を提供します。 次は、異なる型のパターンの値とマッチする、2 つめの例です object MatchTest2 extends Application { def matchTest(x Any) Any = x match { case 1 = "one" case "two" = 2 case y Int = "scala.Int" } println(matchTest("two")) } もし x が整数値 1 を参照するなら、最初のケースがマッチします。もし x が文字列 "two" と等しければ、2 つめのケースがマッチします。3 つめのケースは型付きパターンから成ります; それは任意の整数にマッチし、セレクター値 x を整数型の変数 y に束縛します。 Scala のパターンマッチング文は、ケースクラス [10]を介して表現される代数型上のマッチングにおいて、最も役に立ちます。 Scala ではまた、抽出子オブジェクト [59]中の unapply メソッドを使って、ケースクラスとは独立にパターンを定義できます。 Scala ひと巡り 多相的メソッド (Polymorphic Methods) 原ページ Scala 中のメソッドは、値と型の両方でパラメータ化できます。クラスレベルのように、値パラメータは丸括弧の対で囲み、他方、型パラメータは対の角括弧内で宣言します。 次は 1 つの例です object PolyTest extends Application { def dup[T](x T, n Int) List[T] = if (n == 0) Nil else x dup(x, n - 1) println(dup[Int](3, 4)) println(dup("three", 3)) } オブジェクト PolyTest 中のメソッド dup は、型 T と値パラメータ x T、n Int でパラメータ化されています。メソッド dup が呼び出されると、プログラマは必要とされるパラメータを提供しますが(上記プログラム中の 5 行目参照)、上記プログラムの 6 行目のように、プログラマは実際の型パラメータを明示的に与える必要はありません。Scala の型システムは、そのような型を推論できます。それは、与えられた値パラメータの型と、メソッドが呼ばれるコンテキストを調べることで、なされます。 トレイト Application は短いテストプログラムを書くために設計したのですが、JVM の出力コード最適化能力を動揺させるようなプログラムを書くことは避けるべきでしょう。この代わりに def main() を使ってください。 Scala ひと巡り 正規表現パターン (Regular Expression Patterns) 原ページ 右無視シーケンスパターン 右無視パターンは、Seq[A]のサブ型あるいは、(たとえば下記のような)反復する形式上のパラメータをもつケースクラスなどのデータ分解に役立つフィーチャーです。 Elem(prefix String, label String, attrs MetaData, scp NamespaceBinding, children Node*) これらの場合、Scala は、任意長のシーケンスを表すワイルドカード-星印 _ * を最右端にもつパターンを許しています。 次は、シーケンスの前部とマッチし、残りを変数 restへ束縛する、パターンマッチの例です。 object RegExpTest1 extends Application { def containsScala(x String) Boolean = { val z Seq[Char] = x z match { case Seq('s','c','a','l','a', rest @ _*) = println("rest is "+rest) true case Seq(_*) = false } } } 次に述べる理由により、前 Scala バージョンと違い、もう任意の正規表現は使用できません。 Scala から当面の間除かれた一般的な Regexp パターン 正当性の問題が見つかり、このフィーチャーは当面の間 Scala 言語から除かれています。もしユーザーコミュニティーからのリクエストがあれば、私たちはこれを改善した形で復活させるかもしれません。 私達の考えでは、正規表現パターンは私たちが見積もったほどには XML 処理に役立ちませんでした。現実の XML 処理アプリケーションでは、XPath ははるかに良い選択肢に思われます。変換処理あるいは正規表現パターンが、あまり使われずしかも取り除くことが難しい難解なパターンに対していくつかのバグをもつということを見つけたとき、言語を単純化する時が来たと私達は判断しました。 前 はじめ 次
https://w.atwiki.jp/scale/pages/9.html
@wikiにはいくつかの便利なプラグインがあります。 アーカイブ コメント ニュース 人気商品一覧 動画(Youtube) 編集履歴 関連ブログ これ以外のプラグインについては@wikiガイドをご覧ください = http //atwiki.jp/guide/
https://w.atwiki.jp/tmiya/pages/126.html
Scala ひと巡り 抽象型 (Abstract Types) 原ページ Scala では、クラスは値(コンストラクタ・パラメータ)と(もしクラスがジェネリック [16]なら)型でパラメータ化されます。単に規則に従って、オブジェクトメンバーとして値を持てるというばかりではありません; 値と同様に、型はオブジェクトのメンバーです。さらに、メンバーの両形式とも、具象あるいは抽象で構いません。 次の例は、クラス Buffer のメンバーとして、延期された値定義と抽象型定義の両方を定義しています。 abstract class Buffer { type T val element T } 抽象型はその正体が正確には知られていない型です。上記の例で、我々は、クラス Buffer の各オブジェクトが 型メンバー T を持つことだけを知っています。しかしクラス Buffer の定義は、メンバー型 T がどのような具象(具体的な)型に対応するのかを明らかにしません。値定義と同じように、サブクラス中で型定義をオーバライドできます。これにより、(可能な、抽象型の具象インスタンス化を記述する)型境界を厳しくすることで、抽象型についてより多くの情報を明らかにできます。 次のプログラムで、型 T が新しい抽象型 U のサブ型でなければならないと述べることで、バッファ中にシーケンスのみを記憶できるクラス SeqBuffer を得ます abstract class SeqBuffer extends Buffer { type U type T Seq[U] def length = element.length } 抽象型メンバーをもつトレイトあるいはクラス [2]は、無名クラスのインスタンス化との組合せでしばしば使われます。この例として、整数リストを参照するシーケンスバッファを扱う、次のプログラムを見てみます。 abstract class IntSeqBuffer extends SeqBuffer { type U = Int } object AbstractTypeTest1 extends Application { def newIntSeqBuf(elem1 Int, elem2 Int) IntSeqBuffer = new IntSeqBuffer { type T = List[U] val element = List(elem1, elem2) } val buf = newIntSeqBuf(7, 8) println("length = " + buf.length) println("content = " + buf.element) } メソッド newIntSeqBuf の戻り値型は、型 U が toInt に等しい、トレイト Buffer の特化を参照します。メソッド newIntSeqBuf 本体内における無名クラスのインスタンス化で、似たような型エイリアスを使っています。そこでは、型 T が List[Int]を参照する、IntSeqBuffer の新しいインスタンスを生成します。 抽象型メンバーをクラスの型パラメータに変えることや、その逆も可能であることに注意してください。次は、上記コードの型パラメータだけを使うバージョンです abstract class Buffer[+T] { val element T } abstract class SeqBuffer[U, +T Seq[U]] extends Buffer[T] { def length = element.length } object AbstractTypeTest2 extends Application { def newIntSeqBuf(e1 Int, e2 Int) SeqBuffer[Int, Seq[Int]] = new SeqBuffer[Int, List[Int]] { val element = List(e1, e2) } val buf = newIntSeqBuf(7, 8) println("length = " + buf.length) println("content = " + buf.element) } ここでは変位指定アノテーション [17]を使う必要があることに注意してください; そうでなければ、メソッド newIntSeqBuf が返すオブジェクトの具象シーケンス実装型を隠せなくなります。さらにまた、型パラメータを抽象型で置き換えできない場合があります。 Scala ひと巡り アノテーション (Annotations) 原ページ アノテーションは、定義にメタ情報を関連づけます。 単純なアノテーション節は、@C あるいは @C(a1,...,an) の形です。ここで、C はクラス C のコンストラクタで、scala.Annotation [31]に適合しなくてはなりません。 All given constructor_arguments a1,...,an must be constant_expressions (i.e., expressions on numeral literals, strings, class_literals, Java enumerations and one-dimensional arrays of them) . 与えられたコンストラクタ引数 a1,...,an はすべて、定数式(すなわち、数値リテラル、文字列、クラスリテラル、Java enumとそれらの 1 次元配列上の式)でなければなりません。 アノテーション節は、その後に続く、最初の定義または宣言に適用されます。1 つ以上のアノテーション節が定義や宣言に先行するかもしれません。それら節の与えられた順番は重要ではありません。 アノテーション節の意味は処理系依存です。Java プラットフォームでは、次の Scala アノテーションは標準的な意味を持っています。 Scala Java scala.SerialVersionUID [32] serialVersionUID [33] (フィールド) scala.cloneable [34] java.lang.Cloneable [35] scala.deprecated [36] java.lang.Deprecated [37] scala.inline [38] (2.6.0から) 等価なもの無し scala.native [39] (2.6.0から) native [40] (キーワード) scala.remote [41] java.rmi.Remote [42] scala.serializable [43] java.io.Serializable [44] scala.throws [45] throws [40] (キーワード) scala.transient [46] transient [40] (キーワード) scala.unchecked [47] (2.4.0から) 等価なもの無し scala.volatile [48] volatile [40] (キーワード) scala.reflect.BeanProperty [49] Design pattern [50] 次の例では、Java main プログラム中で例外送出をキャッチするために、メソッド read の定義に throws アノテーションを加えています。 Java コンパイラは、どのチェック例外がメソッドあるいはコンストラクタの実行によって引き起こされるか分析し、プログラムがチェック例外 [51]用のハンドラを含むことを確認します。起きる可能性のある各チェック例外に対して、メソッドあるいはコンストラクタの throw 節では、その例外クラスあるいはその例外クラスのスーパークラスの 1 つに言及しなくてはなりません。 Scala にはチェック例外がないので、Java コードが Scala メソッドの送出する例外を捕えることができるように、Scala メソッドに 1 つ以上の throws アノテーションをつける必要があります。 package examples import java.io._ class Reader(fname String) { private val in = new BufferedReader(new FileReader(fname)) @throws (classOf [IOException]) def read() = in.read() } (訳注 thorws [45], classOf [52] ) 次の Java プログラムはファイルの内容を印字します。ファイル名は main メソッドに最初の引数として渡されます。 package [[test]]; import examples.Reader; // Scala クラス !! public class AnnotaTest { public static void main(String[] args) { try { Reader in = new Reader(args[0]); int c; while ((c = in.read()) != -1) { System.out.print((char) c); } } catch (java.io.Exception e) { System.out.println(e.getMessage()); } } } クラス Reader 中の throws アノテーションをコメントアウトすると、Java main プログラムのコンパイル時に、次のエラーメッセージが出力されます Main.java 11 Exception java.io.IOException is never thrown in body of corresponding try statement } catch (java.io.IOException e) { ^ 1 error Java アノテーション 注意 Java アノテーションの -target jvm-1.5 オプションの使用を確認してください。 Java 1.5 は、アノテーション [53]の形でユーザー定義メタデータを導入しました。アノテーションの重要な特徴は、指定された名前と値の対を信頼して、それら要素を初期化することです。 例えば、もしあるクラスのソースを追跡するアノテーションが必要なら、次のように定義するかもしれません。 Java annotations @interface Source { public String URL(); public String mail(); } それを次のように適用してください @Source(URL = "http //coders.com/", mail = "support@coders.com") public class MyClass extends HisClass ... Scala のアノテーション適用は、Java アノテーションのインスタンス化のために名前付き引数を使う必要があるので、コンストラクタ呼び出しのように見えます。 @Source(URL = "http //coders.com/", mail = "support@coders.com") class MyScalaClass ... もしアノテーションが(デフォルト値をもたない) ただ 1 つの要素を含むだけなら、この構文はたいへんうんざりします。そこで、規約により(by convention)、もし名前を値として指定するなら、それをコンストラクタに似た構文を使って Java 中で適用できます。 @interface SourceURL { public String value(); public String mail() default ""; } それを次のように適用してください @SourceURL("http //coders.com/") public class MyClass extends HisClass ... In this case, Scala provides the same possiblity. この場合、Scala は同じことを提供します。 @SourceURL("http //coders.com/") class MyScalaClass ... mail 要素はデフォルト値を指定されているので、それに明示的に値を与える必要はありません。しかし、もしそうする必要があっても、Java 中で 2 つのスタイルを混ぜて適応させることはできません。 @SourceURL(value = "http //coders.com/", mail = "support@coders.com") public class MyClass extends HisClass ... Scala はこの点に関してより柔軟です。 @SourceURL("http //coders.com/", mail = "support@coders.com") class MyScalaClass ... この拡張された構文は、.NET のアノテーションでも同じあり、それらアノテーションのフルの能力を引き出します。 Scala ひと巡り クラス (Classes) 原ページ Scala のクラスは静的なテンプレートであり、実行時にたくさんのオブジェクトへインスタンス化されます。 次は、クラス Point を定義するクラス定義です class Point(xc Int, yc Int) { var x Int = xc var y Int = yc def move(dx Int, dy Int) { x = x + dx y = y + dy } override def toString() String = "(" + x + ", " + y + ")"; } クラスは 2 つの変数 x と y、2 つのメソッド move と toString を定義します。move は 2 つの整数を引数にとりますが、値を返しません (暗黙の戻り値型 Unit は、Java ライクな言語の void に相当します)。他方、toString は引数をとらず、String 値を返します。toString は事前定義された toString メソッドをオーバライドするので、override フラグでタグ付けしなければなりません。 Scala のクラスは、コンストラクタ引数でパラメータ化されます。上記のコードは 2 つのコンストラクタ引数 xc と yc を定義します;それらは共にクラス本体全体で可視です。この例では、それらは変数 x と y の初期化に使われています。 クラスは、次の例が示すように、new プリミティブでインスタンス化できます object Classes { def main(args Array[String]) { val pt = new Point(1, 2) println(pt) pt.move(10, 10) println(pt) } } このプログラムは実行可能なアプリケーション Classes を、main メソッドをもつトップレベルのシングルトンオブジェクトの形で定義します。main メソッドは新しい Point を生成し、それを値 pt に記憶します。val 構文で定義された値は更新が許されないという点が、var 構文(上記 クラス Point 参照)で定義された変数とは異なることに注意してください; すなわち、値(value)は不変です。 次はプログラムの出力です (1, 2) (11, 12) Scala ひと巡り ケースクラス (Case Classes) 原ページ Scala はケースクラスの概念をサポートします。ケースクラスは通常のクラスであり、そのコンストラクタ・パラメータをエクスポートし、パターンマッチング [11]を介して再帰的な分解メカニズムを提供します。 次は、1 つの抽象スーパークラス Term と 3 つの具象ケースクラス Var、Fun と App からなるクラス階層の例です。 abstract class Term case class Var(name String) extends Term case class Fun(arg String, body Term) extends Term case class App(f Term, v Term) extends Term このクラス階層は、型付けされていない(untyped) λ計算 [54]の項を表現するのに使えます。ケースクラスのインスタンス構築にあたり、Scala では new プリミティブを使う必要がありません。単純に、クラス名を関数として使用できます。 次は 1 つの例です Fun("x", Fun("y", App(Var("x"), Var("y")))) ケースクラスのコンストラクタ・パラメータは公開の値として扱われ、直接アクセスできます。 val x = Var("x") Console.println(x.name) すべてのケースクラスに対して、Scala コンパイラは、構造的等価性を実装する equals メソッドと toString メソッドを生成します。たとえば val x1 = Var("x") val x2 = Var("x") val y1 = Var("y") println("" + x1 + " == " + x2 + " = " + (x1 == x2)) println("" + x1 + " == " + y1 + " = " + (x1 == y1)) は、次のように印字するでしょう。 Var(x) == Var(x) = true Var(x) == Var(y) = false もしパターンマッチングをデータ構造の分解に使うなら、ケースクラスを定義するのが妥当です。次のオブジェクトは、λ計算を表現するプリティプリンタ関数を定義します object TermTest extends Application { def printTerm(term Term) { term match { case Var(n) = print(n) case Fun(x, b) = print("^" + x + ".") printTerm(b) case App(f, v) = Console.print("(") printTerm(f) print(" ") printTerm(v) print(")") } } def isIdentityFun(term Term) Boolean = term match { case Fun(x, Var(y)) if x == y = true case _ = false } val id = Fun("x", Var("x")) val t = Fun("x", Fun("y", App(Var("x"), Var("y")))) printTerm(t) println println(isIdentityFun(id)) println(isIdentityFun(t)) } この例で関数 print は、パターンマッチング文として表現されており、それは match キーワードで始まる case Pattern = Body 節の並びから成っています。 上記のプログラムは、与えられた項が単純な識別関数に対応するかどうかチェックする関数 isIdentityFun も定義します。この例は、深いパターンとガードを使います。与えられた値をもつパターンとマッチした後、その(キーワード if の後に定義された)ガードが評価されます。もしそれが true を返すなら、マッチは成功です。;そうでなければ失敗であり、次のパターンが試みられます。 Scala ひと巡り 事前定義された classOf 関数 (Predefined function classOf) 原ページ 事前定義された関数 classOf[T]は、 Scala のクラス型 T の実行時表現を返します。次の Scala コード例は、 args パラメータの実行時表現を印字します object ClassReprTest { abstract class Bar { type T AnyRef def bar(x T) { println("5 " + x.getClass()) } } def main(args Array[String]) { println("1 " + args.getClass()) println("2 " + classOf[Array[String]]) new Bar { type T = Array[String] val x T = args println("3 " + x.getClass()) println("4 " + classOf[T]) }.bar(args) } } 次は Scala プログラムの出力です 1 class [Ljava.lang.String; 2 class [Ljava.lang.String; 3 class [Ljava.lang.String; 4 class [Ljava.lang.String; 5 class [Ljava.lang.String; Scala ひと巡り 複合型 (Compound Types) 原ページ ときには、オブジェクトの型が、他の複数の型のサブ型であると表現することが必要になります。Scala では、それをオブジェクト型の論理積である複合型(compound types)の助けを借りて表現できます。 2 つのトレイト Cloneable と Resetable があるとします。 trait Cloneable extends java.lang.Cloneable { override def clone() Cloneable = { super.clone(); this } } trait Resetable { def reset Unit } いま、オブジェクトを引数にとってクローンし、オリジナルのオブジェクトをリセットする関数 cloneAndReset を書きたいとします。 def cloneAndReset(obj ?) Cloneable = { val cloned = obj.clone() obj.reset cloned } パラメータ obj の型は何か、という問題が生じます。もしそれが Cloneable なら、オブジェクトはクローンできますがリセットできません。; しかしもし Resetable なら、リセットできますがクローン操作がありません。そのような状況で型キャストを避けるために、obj の型が Cloneable と Resetable の両方であると指定できます。Scala では、複合型を使って Cloneable with Resetable のように書きます。 次は、アップデートした関数です def cloneAndReset(obj Cloneable with Resetable) Cloneable = { //... } 複合型は複数のオブジェクト型からなり、ただ一つの細別(refinement)を持てます。細別は既存のオブジェクトメンバーのシグニチャを狭めるのに使えます。 一般的な書き方は A with B with C ... { refinement } です。 細別の使用例は、抽象型 [21]に関するページにあります。 Scala ひと巡り シーケンス内包表記 (Sequence Comprehensions) 原ページ Scala は、シーケンス内包表記式に対して簡単な表記法を提供します。内包表記は for enums yield e の形をしています。ここで enums は、セミコロンで分離された列挙子のリストを参照します。列挙子は、新しい変数を導入する生成子、あるいは、フィルタです。内包表記は、列挙子 enum によって生成された各束縛にごとに、本体 e を評価し、それら値のシーケンスを返します。 次は 1 つの例です object ComprehensionTest1 extends Application { def even(from Int, to Int) List[Int] = for (i - List.range(from, to) if i % 2 == 0) yield i Console.println(even(0, 20)) } 関数 even 中の for 式は Int 型の新しい変数 i を導入し、それをリスト List(from,from + 1,...,to - 1) の全ての値へ次々に束縛します。ガード if i % 2 == 0 は、(式 i だけからなる)本体が偶数の場合のみ評価されるよう、全ての奇数をフィルターします。最終的に、for 式全体は偶数のリストを返します。 プログラムは次を出力します List(0, 2, 4, 6, 8, 10, 12, 14, 16, 18) 次はより複雑な例で、その合計が与えられた値 v と等しい、0 から n - 1 までの数の対をすべて計算します。 object ComprehensionTest2 extends Application { def foo(n Int, v Int) = for (i - 0 until n; j - i + 1 until n if i + j == v) yield Pair(i, j); foo(20, 32) foreach { case (i, j) = println("(" + i + ", " + j + ")") } } この例は、内包表記がリストに制限されないことを示しています。前のプログラムは、代わりにイテレータを使っています。(適切な型をもつ) 操作 filter、map そして flagMapをサポートするすべてのデータ型は、シーケンス内包表記中で使えます。 次はプログラムの出力です (13, 19) (14, 18) (15, 17) シーケンス内包表記で Unitを返す、特別の形式もあります。そこでは、生成子のリストとフィルターから生成される束縛は、副作用を起こさせるために使われます。そのようなシーケンス内包表記を利用するには、プログラマはキーワード yield を取り除かなければなりません。 次は、前のものと等価ではあるが Unit を返す、特別な for 内包表記を使うプログラムです。 object ComprehensionTest3 extends Application { for (i - Iterator.range(0, 20); j - Iterator.range(i + 1, 20) if i + j == 32) println("(" + i + ", " + j + ")") } Scala ひと巡り 抽出子オブジェクト (Extractor Objects) 原ページ Scala では、パターンをケースクラスとは独立に定義できます。この目的のために、unapply という名前のメソッドを定義することで、いわゆる抽出子がもたらされます。 例えば、次のコードは抽出子オブジェクト Twice を定義します。 object Twice { def apply(x Int) Int = x * 2 def unapply(z Int) Option[Int] = if (z%2 == 0) Some(z/2) else None } object TwiceTest extends Application { val x = Twice(21) x match { case Twice(n) = Console.println(n) } // prints 21 } 次は、ここで関係する 2 つの文法上の規約(convention)です パターン case Twice(n)は、Twice.unapply の呼び出しを引き起こし、偶数のマッチに使われます。; unapply の戻り値は、引数がマッチしたかどうか、そしてさらなるマッチングのために使えるサブ値を伝えます。ここで、サブ値は z/2 です。 The apply method is not necessary for pattern matching. It is only used to mimic a constructor val x = Twice(21) expands to val x = Twice.apply(21) . apply メソッドは、パターンマッチングについては必須ではありません。これはただ、コンストラクタをまねて val x = Twice(21) を val x = Twice.apply(21) へ展開する時に使われるだけです。 unapply の戻り値型は、次のように選ぶべきです もしそれが単なるテストなら、Boolean を返す。たとえば case even() 。 もしそれがただ一つの、型 T のサブ値を返すなら、Option[T]を返す。 もし複数のサブ値 T1,...,Tn を返したいなら、それらをまとめてタプルのオプション Option[(T1,...,Tn)]として返す。 しばしば、サブ値の数が固定で、シーケンスを返したいことがあります。その場合は、unapplySeq を介して同様にパターンを定義できます。最後のサブ値の型 Tn は、Seq[S]でなければなりません。このメカニズムは、たとえば、パターン case List(x1,...,xn) 中で使われます。 抽出子を使えば、コードはさらに保守しやすくなります。詳細は、Emir [56]、Odersky[57] と Williams (2007 年 1 月) らによる論文「パターンを用いたオブジェクトマッチング」[55](4 章参照) を読んでください。 前 先頭 次
https://w.atwiki.jp/tmiya/pages/30.html
4.1 式と簡単な関数 Scala システムには、素敵な計算機と見ることのできるインタプリタが同梱されています。ユーザーは式をタイプすることで計算機と交信できます。計算機は評価した結果とその型を返します。たとえば scala 87 + 145 unnamed0 Int = 232 scala 5 + 2 * 3 unnamed1 Int = 11 scala "hello" + " world!" unnamed2 java.lang.String = hello world! 部分式に名前を付け、以後は式の代わりにその名前を使うこともできます。 scala def scale = 5 scale Int scala 7 * scale unnamed3 Int = 35 scala def pi = 3.141592653589793 pi Double scala def radius = 10 radius Int scala 2 * pi * radius unnamed4 Double = 62.83185307179586 定義は予約語 def で始まります。= 記号に続く式を表す名前を導入します。インタプリタは導入された名前と型を返します。 def x = e のような定義の実行は、式 e を評価しません。その代わり、x が使われる時はいつでも e は評価されます。一方で、Scala には値の定義 val x = e もあり、定義評価の一環として右辺 e を評価します。その後 x が使われるときは、前に計算された e の値で直ちに置き換えられので、式を再評価する必要はありません。 式はどのように評価されるのでしょう? 演算子とオペランドから構成される式は次の簡単化のステップを繰り返し適用して評価されます。 最も左の操作を選ぶ そのオペランドを評価する オペランド値に演算子を適用する def で定義された名前は、名前を (未評価の) 定義の右辺で置き換えることで評価されます。val で定義された名前は、名前を定義の右辺の値で置き換えることで評価されます。評価プロセスは値を得たら終了します。値は文字列や数や配列やリストといったデータアイテムです。 Example 4.1.1 数式の評価です。 (2 * pi) * radius → (2 * 3.141592653589793) * radius → 6.283185307179586 * radius → 6.283185307179586 * 10 → 62.83185307179586 式を値へと段階的に簡単化するプロセスを 簡約 と呼びます。 前ページ 4 章 目次 次ページ ーーー 修正案murase_syuka s/素敵な計算機のように見えるインタプリタ/高級計算機と見ることができるインタプリタ/ ーーー 名前 コメント
https://w.atwiki.jp/scale/pages/11.html
コメントプラグイン @wikiのwikiモードでは #comment() と入力することでコメントフォームを簡単に作成することができます。 詳しくはこちらをご覧ください。 =>http //atwiki.jp/guide/17_60_ja.html たとえば、#comment() と入力すると以下のように表示されます。 名前 コメント
https://w.atwiki.jp/scale/pages/6.html
更新履歴 @wikiのwikiモードでは #recent(数字) と入力することで、wikiのページ更新履歴を表示することができます。 詳しくはこちらをご覧ください。 =>http //atwiki.jp/guide/17_117_ja.html たとえば、#recent(20)と入力すると以下のように表示されます。 取得中です。
https://w.atwiki.jp/todo314/pages/444.html
Cost-aware Targeted Viral Marketing in Billion-scale Networks Hung T. Nguyen, Thang N. Dinh, My T. Thai INFOCOM 2016 概要 新しい問題 Cost-aware Targeted Viral Marketing ユーザ毎に最初の費用が違う ユーザ毎に影響させた事による効果が違う いい感じにすれば$$ 1-1/\sqrt{e} $$近似が可能 効率的アルゴリズム BCT:CTVMにもInfMaxにも適用可能 LISA [CSoNet 15]の後続 Cost-aware Targeted Viral Marketing 費用$$c(u)$$、利益$$b(u)$$、予算$$B$$ 目的関数:Sの影響した頂点uの利益b(u)の総和 制約:$$c(S) \leq B$$ いわゆるBudgeted Influence MaximizationやTargeted Viral Marketingの一般化 提案手法 BCT CTVM特有の話題 サンプリング 頂点利益に重み付けした確率でサンプリングすればOK Coarsening Massive Influence Networksのと同じ奴ね シード選択 (サンプリング後)次の内、良い方を返す $$ \frac{F_{\mathcal{R}}(S+v)-F_{\mathcal{R}}(S)}{c(v)} $$で貪欲 $$ F_{\mathcal{R}}(v) $$最強の(制約を満たす)頂点v RR集合のバウンド $$ \Lambda_L \leq 7.4 \epsilon^{-2} \left[ \ln \delta^{-1} + \ln {n \choose k} + \frac{2}{n} \right] $$ 倍々にRR集合を増やし、貪欲算法を走らせる→解S $$ |\mathcal{R}| \cdot F_{\mathcal{R}}(S) \geq \Lambda_L $$なら終了 単一頂点ではないのがLISAとの違い 解析は何か頑張っている ICもLTも対応出来る 実験 辺確率:というかLTモデルだけっぽい 比較手法:TIM, TIM+, CELF++, SIMPATH++ まとめ はい。 実験設定が微妙 2017/10/01